Print function

You can print the value on the console with print() function.

print("Hello World!")

[1] "Hello World!"

print() function is implicitly called if not supplied.

"Hello there!"

[1] "Hello there!"

Basic Calculations

You can use R to do basic math calculations.

1 / 200 * 30

[1] 0.15

(59 + 73 + 2) / 3

[1] 44.66667

Question: What is 500 * (100 / 2.5) + 770?

Arithmetic Operators

• Addition (+), Subtraction (-)
• Multiplication (*), Division (/)
• Exponentiation (^ or **)
• Modulo (%%): Returns the remainder of a division

5 %% 3

[1] 2

• Integer Division (%/%): Returns the integer quotient

8 %/% 3

[1] 2

Logical Test Operators

• Less than (< or >)
• Less than or equal (<= or >=)
• Equality (==) and Inequality (!=)
• Logical NOT (!)
• Element-wise AND (&), OR (|)

Exercise: Check

• 3 >= 5,
• TRUE == FALSE,
• TRUE & FALSE,
• (3 > 1) & (3 <= 5)
• TRUE | FALSE,
• !TRUE == FALSE
• !(3 > 1) & (3 <= 5)

Comments

Comments are meant to explain the code and redable, but ignored by the computer.

• Use # to make comment
• Anything written after # on the line are ignored

# this is comment
1 + 2 # This is another comment

[1] 3

Scalar

A scalar in R is a simplest data type and represents a single element, not a collection.

10 # Number
"New to R" # Character
TRUE # logical

Atomic Vector

To combine multiple elements to a vector, use c() function.

c(1, 2) # 2 elements

[1] 1 2

c(2, 3, 4, 6, 7) #5 elements

[1] 2 3 4 6 7

c(3) # 1 length vector, same as scalar 

[1] 3

Integer sequence

Colon : generates integer sequence from:to.

1:10

 [1]  1  2  3  4  5  6  7  8  9 10

-5:2

[1] -5 -4 -3 -2 -1  0  1  2

3:-5

[1]  3  2  1  0 -1 -2 -3 -4 -5

Length of a vector

To check the number of elements of a vector, use length() function:

length(3) # Scalar is length 1 vector

[1] 1

length(c(5))

[1] 1

length(c(1, 2, 3))

[1] 3

Vectorized operations

Vectorized operations mean vector-in-vector-out, as opposed to scalar operation (one-in-one-out).

In R, most operations are vector in mind.

For example, + and * are vectorized operators.

c(1, 3, 5) + c(2, 3, 4) # plus on each element of vector
c(5, 6, 7, 8) * 3 # multiply each (recycle x3 to all elements)

Question:

What do you get when c(2,3) * c(3,9)?

What’s the length of the output?

Recycling rule

When the operands are of different lengths, the shorter one is recycled as many times as necessary.

# Try !
1:10 / 3
1:10 * c(-1,1)
5 ^ c(1,3,5)

When it cannot be recycled entirely, it still works but raises a warning message:

# Try !
c(1, 10, 100) * 1:5

Why vectorized?

For computers, using vectorization or not is like a difference in our mental calculation between

• 3 * 9 and
• (3 + 3 + 3 + 3 + 3 + 3 + 3 + 3 + 3).

REPL vs Scripting

REPL: Interactive programming

So far, we’ve done interactive programming, REPL:

• Read, Evaluate, Print, Loop
• For rapid prototyping, exploration, debugging, etc.

Continuation Prompt

> cat("Here's command I'm typing
+ but it was unfinished
+ so R waits until I finish expression...
+ 
+ hitting Enter doesn't abort at all..
+
+ press ESC or CTRL+C to abort 
")

On console: > means: “Waiting your command”

+ means: “Continue command”

CTRL + C to abort.

Script (Batch)

Instead, you can run the whole script outside of R environment, using Rscript

# from outside of R environment (e.g., bash)
Rscript my_code.R

Running a script file on current R session:

# from inside of R environment
source("my_code.R")

Writing a complete script is your final goal in programming.

• For production and deployment

Binding Names (Symbols)

Use <- to bind a name (symbol) to an object.

# object of 3 is created, bind its name to my_number
my_number <- 3 
print(my_number * 3)

[1] 9

Here, my_number is called symbol, or name of an object.

R has strict rules about a syntactic name (symbol).

• It is case sensitive

a <- 3
print(A)

Error: object 'A' not found

• It cannot contain whitespace

my number <- 1 # error

Error in parse(text = input): <text>:1:4: unexpected symbol
1: my number
       ^

• It cannot start with numbers

my_number_1 <- 15
1_my_number <- 10 # error

Error in parse(text = input): <text>:2:2: unexpected input
1: my_number_1 <- 15
2: 1_
    ^

• You can’t use reserved words like TRUE, NULL, if, etc.

• If you’d deliberately use non-syntactic names, use backtick `

# Use backtick escaping only when you have to
`my number` <- 1
print(`my number`)

[1] 1

Object naming conventions

Since objects cannot contain whitespace as symbol, there are some naming conventions.

• snake_case

• camelCase

• PascalCase

when_you_have_very_long_name_object <- 12
YouCanNameItLikeThis <- 1

Interactive prompt

readline() gemerates prompt for interactive input.

readline("What is your age?")

The response can be a value and assigned as an object.

response_age <- readline("What is your age?")

Evaluating vs Assigning

Consider the following code. What is the printed value of a?

a <- 3.5
a * 2
print(a)

The expression a * 2 is evaluated but not assigned to any variable, so a remains unchanged.

To store the result, you need to assign it:

a <- a * 2 # overwrite or
b <- a * 2 # assign to other symbol

Object types in R

• Vector type: Common data types

• Special type (non-vector): non-vectors

  • Functions, Environments, etc.

Vectors are the most important family of data types in R.

Vector type

Vector is a data structure that stores multiple elements. It comes in two flavors:

• Atomic vector: all elements same type
• Generic vector: known as list, can have different types of elements

NULL is not a vector, but often serves as zero length vector.

Atomic vectors

There are four primary types of atomic vector in R, and two others.

Missing values: NA

• Missing values are denoted by NA
  • Not Applicable: similar to “undefined” above
• They are not identical to zero or NULL
  • NULL is intentional empty “placeholder” in R

NA is considered as logical length 1 vector.

typeof(NA) # "logical"
length(NA) # 1

NULL is a special type (NULL), length 0

typeof(NULL) # "NULL"
length(NULL) # 0

NaN a numeric missing value, length 1.

• unrepresentable numeric results (e.g., 0/0, log(-1)).

typeof(NaN) # "double"
length(NaN) # 1

List

List is a generic vector that is not atomic.

• Atomic vector can have only one type for its elements (Double, Integer, Logical, …)

• List can hold multiple data types for its member (even list itself)

example_list <- list(1L, 3.5, 'Hi', TRUE)
print(example_list)

[[1]]
[1] 1

[[2]]
[1] 3.5

[[3]]
[1] "Hi"

[[4]]
[1] TRUE

typeof(example_list)

[1] "list"

List can have atomic vectors as its elements, with varying lengths:

# List construction example
# Use "=" inside function
my_list <- list(
  first_element = c(1L, 2L, 3L), # integer type, length of 3
  second_element = c('how', 'what', 'why', 'where'), # character type, length 4
  third_element = c(3 < 5, 3 == 5, 3 > 5) #logical type, length 3
)
typeof(my_list)

[1] "list"

Question: What is the length of my_list?

Attributes

Attributes are metadata that is attached to R objects, providing additional information or functionality.

Common attributes:

• Names: Labels for elements in a vector or list

• Dimensions (dim): Used for matrices, arrays

• Class: Defines how an object should be treated by functions

• etc.

Names attribute

Elements of vector (atomic, generic) can be named.

stock_prices <- c(150, 200, 250, 300)
attributes(stock_prices) # No attributes

NULL

There are roughly three ways to assign names attribute.

Method 1: names()

In R, often used attributes has its own access function named after its own, such as names(), class(), dim().

names(stock_prices) <- c("AAPL", "GOOG", "MSFT", "AMZN")
attributes(stock_prices) # stock_prices now have "names" attribute

$names
[1] "AAPL" "GOOG" "MSFT" "AMZN"

print(stock_prices)

AAPL GOOG MSFT AMZN 
 150  200  250  300 

Method 2: attr()

Or use attr() function to set attribute:

# method 3
stock_prices <- c(150, 200, 250, 300)
attr(stock_prices, "names") <- c("AAPL", "GOOG", "MSFT", "AMZN")
attributes(stock_prices)

$names
[1] "AAPL" "GOOG" "MSFT" "AMZN"

Method 3: by construct

Or assign names by construct:

# method 2
stock_prices2 <- c(
  "AAPL" = 150,
  "GOOG" = 200,
  "MSFT" = 250,
  "AMZN" = 300
)
attributes(stock_prices2)

$names
[1] "AAPL" "GOOG" "MSFT" "AMZN"

Exercise

stock_prices <- c(100, 150)

Give names attribute to stock_prices vector using aforementioned three methods.

• names(obj) <-
• attr(obj, "names") <-
• by construct

Dim attribute

Adding a dim attribute to a vector allows it to behave like a 2-dimensional matrix or a multi-dimensional array.

# matrix
x <- 1:6
dim(x) <- c(2, 3) # assign 2 by 3 dimension attribute
print(x)

     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

# array
y <- 1:8
dim(y) <- c(2, 2, 2) # 2 by 2 by 2
print(y)

, , 1

     [,1] [,2]
[1,]    1    3
[2,]    2    4

, , 2

     [,1] [,2]
[1,]    5    7
[2,]    6    8

Class attribute

The class attributes in R is used to define the behavior of objects with functions.

Especially important classes in Finance are:

• Date, Time
• Factors
• Dataframe
• or your own custom-built class

Example 1: Date/Time

Very important class in Finance.

They are built from double type atomic vector (type), but has own specific rule for uses (class).

today <- Sys.Date() # returns today's date
now <- Sys.time() # returns time now
print(today)

[1] "2026-02-08"

print(now)

[1] "2026-02-08 15:43:35 EST"

Check their data type:

typeof(today)

[1] "double"

typeof(now)

[1] "double"

Check their attributes: they have class attributes.

attributes(today)

$class
[1] "Date"

attributes(now)

$class
[1] "POSIXct" "POSIXt" 

To directly access the class attribute:

class(today)

[1] "Date"

class(now)

[1] "POSIXct" "POSIXt" 

Class attribute and change of behavior

For an example, see how it works with + function.

print(today + 1) # adds one day

[1] "2026-02-09"

print(now + 1) # adds one seconds

[1] "2026-02-08 15:43:36 EST"

Q: Why +1 yield different results?

A: Because they are in different classes. +1 is inferred differently.

Class attribute gives some context how it should behave with functions.

In the deep down, they are just numbers:

# strip off class attribute (only)
unclass(today)

[1] 20492

unclass(now)

[1] 1770583416

• Date: The value of double represents the number of days since “1970-01-01” (Unix Epoch)
• Time: the number of seconds since Unix Epoch

Time zone attribute

Time has “tzone” attribute (time-zone) that controls “formatting” of date-time.

• The lower-level data (double) for the time is not changing.

now <- Sys.time()
print(now) # EDT time zone

[1] "2026-02-08 15:43:36 EST"

unclass(now) # a double number

[1] 1770583416

# set attribute tzone to UTC
attr(now, "tzone") <- "UTC"
print(now) # formatted for UTC zone

[1] "2026-02-08 20:43:36 UTC"

unclass(now) # same underlying number

[1] 1770583416
attr(,"tzone")
[1] "UTC"

Example 2: Factors

Factors (or Categorical) can only have a set of predefined values.

• It is built on top of integer type

# Factors can be ordered 
firm_size <- factor(
  c("Large", "Mid", "Small"),
  levels = c("Small", "Mid", "Large"), # predetermined values
  ordered = TRUE # give increasing order to above level
)
typeof(firm_size)

[1] "integer"

class(firm_size)

[1] "ordered" "factor" 

# Factors are unordered by default
political_parties <- factor(
  c("Democratic", "Republican")
) # unordered
typeof(political_parties)

[1] "integer"

class(political_parties)

[1] "factor"

If they were stripped off all attributes:

attributes(firm_size) <- NULL # remove all attributes
firm_size # integer (it gave greater number for higher level)

[1] 3 2 1

Base types and Class

Example 3: Dataframe & tibble

A class built on top of list type, with 2D tabular representations

• Similar to matrix (2D form)
• Dataframe and tibble can have different types of columns

# iris is available dataframe
head(iris) # prints first 6 rows

  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa
4          4.6         3.1          1.5         0.2  setosa
5          5.0         3.6          1.4         0.2  setosa
6          5.4         3.9          1.7         0.4  setosa

typeof(iris) # list type

[1] "list"

class(iris)

[1] "data.frame"

If class attribute was removed: it turns back to list

# Try !
iris_list <- unclass(iris)
print(iris_list)

Let’s browse the attributes of iris dataframe:

# names (column names), class, row.names
attributes(head(iris))

$names
[1] "Sepal.Length" "Sepal.Width"  "Petal.Length" "Petal.Width"  "Species"     

$row.names
[1] 1 2 3 4 5 6

$class
[1] "data.frame"

Tibble is a robust dataframe class.

• It has better printing output than data.frame
• Convert class with as_tibble()

iris_tb <- as_tibble(iris)
iris_tb |> head(3)

# A tibble: 3 × 5
  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
         <dbl>       <dbl>        <dbl>       <dbl> <fct>  
1          5.1         3.5          1.4         0.2 setosa 
2          4.9         3            1.4         0.2 setosa 
3          4.7         3.2          1.3         0.2 setosa 

iris_tb |> typeof()

[1] "list"

Implicit Class

Those “building-block” types in R have implicit class:

• Atomic vectors: (primary data types - Logical, Integer, Double, Character)
• Generic vector (list)
• Matrix / Array
• etc.

Their class is not shown in the attributes(), but still shown when explicitly asked with class()

Importance of class

Since class determines the behavior of the object, it is crucial to know your data class especially performing function calls.

As you cannot use add function on character and numeric.

# Another way to perform plus
`+`(3, 4) # good

[1] 7

`+`(3, "Hi") # error

Error in 3 + "Hi": non-numeric argument to binary operator

Other example: c()

Some functions coerces the class / type instead.

my_vector <- c(1, 3, 'hello', 5) # Does it work?
typeof(my_vector)

[1] "character"

class(my_vector) # it works by coercion

[1] "character"

Exercise: coercion

Let’s see how coercion works with c().

test <- c(3.14, Sys.Date(), Sys.time())

What is the type of test?

What is the class of test?

Coercion precedence

In general, coercion is performed in fixed order:

Character (heavy) << Double << Integer << Logical (light)

typeof(c(TRUE))

[1] "logical"

typeof(c(TRUE, 2L))

[1] "integer"

typeof(c(TRUE, 2L, 3.14))

[1] "double"

typeof(c(TRUE, 2L, 3.14, "A"))

[1] "character"

Quick Check

What would be the type of:

typeof(c(TRUE, 3.55))
typeof(c(3L, 5.3))
typeof(c(3L, "2.15"))
typeof(c(TRUE, 3L, 3.34, "2.15"))
typeof(c(TRUE, "FALSE"))

Data type and memory footprint

Given the same length, logical and integer takes least amount of memory, then double, then character

lobstr::obj_size(c(TRUE, FALSE, TRUE)) # uses integer for memory footprint internally

64 B

lobstr::obj_size(c(3L, 15L, -5L))

64 B

lobstr::obj_size(c(3.12, 53.1, 6.22))

80 B

lobstr::obj_size(c("A", "B", "C"))

248 B

Vector Indexing

• Single square brackets [ and ]

  • Subset multiple elements from vector

• Double brackets [[ and ]]

  • Subset single element (scalar) from vector

Vector indexing: Single brackets

Square brackets [ selects multiple elements of vector

• by index: x[1] retrieves first element
• by name: x[“Bob”] retrives element named “Bob”

prices <- c(AAPL = 150, MSFT = 205, GOOGL = 250, AMZN = 303)

# Access by name attributes

prices[["AAPL"]] # single (double bracket)

[1] 150

prices[c("MSFT", "GOOGL")] # multiple (single bracket)

 MSFT GOOGL 
  205   250 

Elements can be accessed with index:

• Positive integer: select
• Negative integer: exclude

# Access by index
prices[1] # first element
prices[c(1, 3)] # 1st and 3rd element
prices[-c(1, 4)] # excluding first and fourth element

• You can’t mix positive and negative index

prices[c(-1, 5)]

Error in prices[c(-1, 5)]: only 0's may be mixed with negative subscripts

Vector indexing: Double brackets

Use double brackets [[ on vector when you want to select single element (Scalar).

# single value from an atomic vector
prices[1] # Ok (keeps names)

AAPL 
 150 

prices[[1]] # Better

[1] 150

Subset & Assignment on Vector

Subsetting vector can be combined with assignment <- to modify selected values.

print(prices)

 AAPL  MSFT GOOGL  AMZN 
  150   205   250   303 

prices[[1]] <- 235 # use double bracket for single element selection
print(prices)

 AAPL  MSFT GOOGL  AMZN 
  235   205   250   303 

prices[["AMZN"]] <- 295
print(prices)

 AAPL  MSFT GOOGL  AMZN 
  235   205   250   295 

Assigning multiple elements:

# Use single bracket for multiple elements
prices[c(2,4)] <- 265 
print(prices)

 AAPL  MSFT GOOGL  AMZN 
  235   265   250   265 

You can subset vector with logical vector inside brackets:

prices[prices > 230] # subset price greater than 200

 AAPL  MSFT GOOGL  AMZN 
  235   265   250   265 

(prices %% 2) == 0 # a logical vector : TRUE if even number

 AAPL  MSFT GOOGL  AMZN 
FALSE FALSE  TRUE FALSE 

is_even <- (prices %% 2) == 0
prices[is_even] # subset of x that is even number

GOOGL 
  250 

prices[(prices %% 2) == 0] # is the same as above

GOOGL 
  250 

Exercise

Generate below stock prices:

stock_prices <- c(TSLA = 680, FB = 355, NFLX = 540, NVDA = 800, AAPL = 145)

Subset and get the following:

• Stocks whose prices greater than $250
• Subset stocks whose prices that are even
• Modify prices greater than $600 to $360

List Indexing

There are 3 ways to index lists that each has own merits:

• Single square brackets [ ] : returns original (list) type
• Double square brackets [[ ]] : returns element’s type
• Dollor sign operator $

A list is like a train carring multiple cars:

x <- list(1:3, "a", 4:6)

List Indexing: Single brackets

Single bracket returns a list object, train.

x[1]

[[1]]
[1] 1 2 3

List Indexing: Double brackets

Double bracket returns element’s type, car.

x[[1]]

[1] 1 2 3

List Indexing: $ Operator

$ is a shorthand operator for double bracket [[ with a variable name.

• Access variable without quotes (")
• Autocompletion friendly

# They are (roughly) equivalent
x[["var1"]]
x$var1

Portfolio example

Construct a list of portfolio:

portfolio <- list(
  stocks = c(AAPL = 150, TSLA = 680),
  bonds = c(TBOND = 1000),
  cash = 5000,
  brokerage = 'Robinhood'
)

Subset by number index:

portfolio[[1]] # double bracket: returns vector (element type)
portfolio[1] # single bracket: returns list

Subset by name:

portfolio[["bonds"]] # double bracket: returns vector
portfolio["bonds"] # single bracket: returns list

portfolio$bonds # dollar sign: returns vector

Assignment on Lists

You can use chained bracket operation and assignment:

portfolio[["stocks"]][["TSLA"]] <- 630 # replacement
portfolio[["bonds"]][["TBOND5Y"]] <- 210 # new value
print(portfolio)

$stocks
AAPL TSLA 
 150  630 

$bonds
  TBOND TBOND5Y 
   1000     210 

$cash
[1] 5000

$brokerage
[1] "Robinhood"

You can remove a component of list by assigning NULL

portfolio[["brokerage"]] <- NULL
print(portfolio)

$stocks
AAPL TSLA 
 150  630 

$bonds
  TBOND TBOND5Y 
   1000     210 

$cash
[1] 5000

Element removal on atomic vectors

Assigning NULL to an element of a vector doesn’t work:

prices <- c(100, 200, 300)
prices[[1]] <- NULL # Doesn't work

Error in prices[[1]] <- NULL: replacement has length zero

Should use negative indexing & overwrite in this case:

prices <- prices[-1] # except for first element
print(prices)

[1] 200 300

Functions

Everything that exists is an object.
Everything that happens is a function call.

— John Chambers

Rewriting to prefix form

An intersting property of R is that every inflix, replacement, and special form can be rewritten in prefix form.

• use backtick ` to wrap the function symbol

1:5 # infix call
`:`(1, 5) # prefix call

x <- c(1, 2) 
names(x) <- c("A", "B") # replacement call
x <- `names<-`(x, c("C", "D")) # prefix call

x[[1]] # special call
`[[`(x, 1) # prefix call

Our first prefix function call, c() concatenates all the values and generate a single object.

• c() has arbitrary number of arguments (...)

# c() function takes arbitrary number of arguments (... part)
c(1, 3, 5) 
c(1, 3, 5, 7, 9)

seq() function generates a sequence of numbers.

• It has three arguments: from and to and by.

# generate a vector of sequence from 1 to 10 by 2
seq(from = 1, to = 10, by = 2)

[1] 1 3 5 7 9

• If users don’t specify the argument name, it reads input in order.

seq(1, 10, 2) # reads first three

[1] 1 3 5 7 9

• If user enters more args than the function space, raises error.

seq(1, 10, 2, 5)

Error in seq.default(1, 10, 2, 5): too many arguments

Some functions has pre-defined argument value:

# max(..., na.rm = FALSE)
max(c(1,2,3,NA)) # NA
max(c(1,2,3,NA), na.rm = TRUE) # 3

Defining a function

You can define custom function (User-defined function) in R with the following syntax:

# simple form
function_name <- function(x, y) function_body

# full form
function_name <- function(arg1, arg2) {
  # write what the function would to with arguments
  return() # output
}

The function can be called in prefix form:

function_name(argument1 = 1, argument2 = "hi")

Default argument value can be assigned by construction:

my_first_function <- function(argument1 = NULL, argument2 = "hi", arg3) {
  
  print(argument2)

}

Q: What would happen if user calls above function with

• my_first_function()

Curly Braces

By default, R evaluates each line as in individual statement.

square_function <- function(x) x^2

Using curly braces { } allows you to group multiple expressions into a single unit that executes together.

some_other_function <- function(x) {
  squared <- x^2         
  result <- squared + 10  
  return(result)         
}

Returning Values in Functions

return() in function can be served as an early exit: all remaining code won’t be executed.

my_second_function <- function(a, b = 1) {
  
  c <- a + b  
  return(c)

  print(a)
}
my_second_function(a = 1, b = 2)

[1] 3

Check formals(), body() and environment():

# formals: list of arguments
formals(some_function) # Is i included? check.
# body: code inside of function
body(some_function)
# environment: where is the function object located
environment(some_function)

Some functions are found from external packages:

environment(stringr::str_glue) # glue function from stringr package

Getting Help on Functions

All R functions are built by someone, and documentation is typically provided.

For detailed description of any function, use ? followed by the function’s name.

For example, try below code in your console:

?seq

Or, use help()

help(seq)

Build a Perpetuity Calculator

The present value of a perpetuity, where the cash flow grows at a constant rate g, is given by:

[ PV_{PER} = ]

where

• PMT is the payment or cash flow.
• r is the discount rate.
• g is the growth rate of the cash flow.

This formula applies when r > g.

Defining a function

You can design your perpetuity function in R with following syntax:

pv_per <- function(pmt, r, g) {
  # write what the function would to with arguments
  n <- pmt
  d <- r - g

  # then return the result
  return(n / d)
}

Default Arguments

What happens if user doesn’t specify one argument?

pv_per(10000, 0.07) # g is missing!

Error in pv_per(10000, 0.07): argument "g" is missing, with no default

You can set default values for arguments, allowing them to be omitted when calling the function.

# set default g to be zero
pv_per2 <- function(pmt, r, g = 0) {
  n <- pmt
  d <- r - g
  # then return the result
  return(n / d)
}
# prefix call without g specified
pv_per2(10000, 0.07)

[1] 142857.1

Example 2: Black-Scholes Pricing

Functions can do more complex calculations. Following the Black-Scholes put / call pricing formula, we can generate function as below:

bsm_price <- function(S0, K, r, T, sigma, type = "call") {
  d1 <- (log(S0 / K) + (r + 0.5 * sigma^2) * T) / (sigma * sqrt(T))
  d2 <- d1 - sigma * sqrt(T)
  
  if (type == "call") {
    return(S0 * pnorm(d1) - K * exp(-r * T) * pnorm(d2))
  } else if (type == "put") {
    return(K * exp(-r * T) * pnorm(-d2) - S0 * pnorm(-d1))
  } else {
    stop("Invalid option type. Use 'call' or 'put'.")
  }
}

Calculate price estimates with four scenarios:

S0 <- c(100, 105, 110, 115)   # Stock prices
K <- c(100, 100, 100, 100)    # Strike prices
r <- 0.05                # Risk-free rate
T <- c(1, 0.5, 2, 0.05)        # Time to maturity
sigma <- c(0.2, 0.25, 0.3, 0.4) # Volatility

bsm_price(S0, K, r, T, sigma) # vectorized operation!

[1] 10.45058 11.47739 28.31895 15.47719

Anonymous function

# Anonymous function example
function(x, y) {
  return(x + y + 1)
}

Functions are typically named so they can be reused multiple times.

However, you can skip naming a custom function, and they are called anonymous function.

• Useful when the function is simple and called only one time.

They are not stored as objects since they do not have assigned symbols (names).

Syntactic sugar: Function

(Anonymous) functions can be defined with syntactic sugar (concise expression):

\(x, y) x + y + 1

\(x, y) {
  x + y + 1
} # or with curly braces

Exercise

Convert below perpetuity function (pv_per) to anonymous function:

pv_per <- function(pmt, r, g) {
  return(pmt / (r - g))
}

Syntactic sugar: Pipe Operator

A Motivating example

Solve below math problem. Describe your steps. What was the first and the last step?

\[ \sqrt{(2+4)^2 - 3 * 4} = ? \]

When we have composite function calls such as

f(g(h(k(x))))

The call sequence is x -> k() -> h() -> g() -> f().

It is rather easier to read, write and debug if we can write a code like:

# Note: this is not a real code!
x then
  call k() on above and then
  call h() on above output and then 
  call g() on above output and then
  call f() on above output

Pipe operator & Function Chain

This is where pipe operator |> becomes handy in R.

The pipe operator does “and then” job, and it can be written as:

x |>
  k() |>
  h() |>
  g() |>
  f() # Do not put pipe at the end!

External packages

Packages are add-on libraries that extend the functionality of R.

• They provide additional functions, datasets, and tools for various tasks
• Can be easily installed with install.packages()
• And loaded in R session with library()

Installing packages:

# Installs tidyverse package if not installed
# Once installed, you don't need to install again
if (!requireNamespace("tidyverse", quietly = TRUE)) {
  install.packages("tidyverse")
}

Load packages: you need to load packages to use its functionality.

• Need to load only once per session

library(tidyverse)

If-else

The basic form of if and if-else statement in R:

# Simple form
if (condition) true_action
if (condition) true_action else false_action

# Full form
if (condition) {
  true_action
} else {
  false_action
}

Example 1: if and else executes code based on logical conditions.

stock_price <- 115
if (stock_price > 110) {
  print("The stock price has increased significantly!")
}

[1] "The stock price has increased significantly!"

Example 2: If condition is not met, then nothing happens (skipped).

stock_price <- 100
if (stock_price > 105) {
  print("The stock price has increased!")
}

Example 3: else if checks one more logic condition:

stock_price <- 115
if (stock_price > 120) {
  print("The stock price has surged!")
} else if (stock_price > 110) {
  print("The stock price has increased moderately.")
}

[1] "The stock price has increased moderately."

Example 4: There can be multiple else if

stock_price <- 108
if (stock_price > 120) {
  print("The stock price has surged!")
} else if (stock_price > 110) {
  print("The stock price has increased moderately.")
} else if (stock_price > 105) {
  print("The stock price has increased slightly.")
}

[1] "The stock price has increased slightly."

Example 5: else is executed when all of if conditions are not met.

stock_price <- 100
if (stock_price > 120) {
  print("The stock price has surged!")
} else if (stock_price > 110) {
  print("The stock price has increased moderately.")
} else if (stock_price > 100) {
  print("The stock price has increased slightly.")
} else {
  print("The stock price has decreased.")
}

[1] "The stock price has decreased."

Exercise

Write an if-else statement:

• If PMT > 1000, add PMT with 10000 (i.e., PMT <- PMT + 10000)
• Else if PMT > 500, add PMT with 100
• Else, set PMT = 0

What is the outcome of above if-else, if initial PMT was 750?

For loops

For loops are used when code has to be iterated a specified number of times.

# Syntax
for (item in vector) {
  action
}

for (i in 1:5) {
  print(i)
}

[1] 1
[1] 2
[1] 3
[1] 4
[1] 5

If for loop was explictly written:

# loop variable i 
i <- 1
print(i)

[1] 1

i <- 2
print(i)

[1] 2

i <- 3
print(i)

[1] 3

i <- 4
print(i)

[1] 4

i <- 5
print(i)

[1] 5

for assigns the item in the current environment, overwriting existing variable with the same name.

i <- 100 # i exists before loop

for (i in 1:3) {}

print(i) # for loop overwrites

[1] 3

Items are accessed one by one in vector in for loop:

tickers <- c("AAPL", "BAC", "C", "DAL")
for (t in tickers) {
  print(t)
}

[1] "AAPL"
[1] "BAC"
[1] "C"
[1] "DAL"

To use index for each element: use seq_along() on the vector.

tickers <- c("AAPL", "BAC", "C", "DAL")
seq_along(tickers) # converts to integer sequence

[1] 1 2 3 4

for (num in seq_along(tickers)) {
  print(num)
}

[1] 1
[1] 2
[1] 3
[1] 4

When looping over date / times, loops strip the attributes:

dates <- as.Date(c("2020-01-01", "2020-05-01"))
for (dat in dates) {
  print(dat)
}

[1] 18262
[1] 18383

To workaround, use indexing with seq_along() and [[.

dates <- as.Date(c("2020-01-01", "2020-05-01"))
for (i in seq_along(dates)){
  print(dates[[i]])
}

[1] "2020-01-01"
[1] "2020-05-01"

For loop: preallocation

Memory Preallocation is creating the full size of the output object before the loop.

For example:

# preallocate empty numeric vector size of 10
output <- vector("numeric", length = 10)
print(output)

 [1] 0 0 0 0 0 0 0 0 0 0

for (i in 1:10) output[[i]] <- i**2 # same as i^2
print(output)

 [1]   1   4   9  16  25  36  49  64  81 100

Best Example

# Think about the type and length of output before loop
N <- 10
output <- vector(mode = "list", length = N) # Create empty list output container

for (n in 1:N) {
  # Good: use square brackets indexing
  output[[n]] <- n**2 
}
print(output)

[[1]]
[1] 1

[[2]]
[1] 4

[[3]]
[1] 9

[[4]]
[1] 16

[[5]]
[1] 25

[[6]]
[1] 36

[[7]]
[1] 49

[[8]]
[1] 64

[[9]]
[1] 81

[[10]]
[1] 100

Bad Example

N <- 10
output <- numeric() # Empty vector without length

for (n in 1:N) {
  # Bad: use c()
  output <- c(output, n**2) 
}
print(output)

 [1]   1   4   9  16  25  36  49  64  81 100

Good Example

If preallocation is cumbersome, use list() for output container then convert to a vector if needed.

N <- 10
output <- list() # Empty list output container without length

for (n in 1:N) {
  # Good: use square brackets indexing
  output[[n]] <- n**2 # same as n^2
}
output <- as.numeric(output) # convert if needed
print(output)

 [1]   1   4   9  16  25  36  49  64  81 100

Research: Benchmarking

N <- 5000
list_prealloc <- vector("list", length = N)
list_noalloc <- list()
vector_prealloc <- vector("numeric", length = N)
vector_noalloc <- numeric()

bench::mark(
  list_prealloc_bracket = for (n in 1:N) {
    list_prealloc[[n]] <- n**2 
  },
  list_noalloc_bracket = for (n in 1:N) {
    list_noalloc[[n]] <- n**2
  }, 
  vector_prealloc_bracket = for (n in 1:N) {
    vector_prealloc[[n]] <- n**2
  },
  vector_noalloc_bracket = for (n in 1:N) {
    vector_noalloc[[n]] <- n**2
  },
  list_noalloc_c = for (n in 1:N) {
    list_noalloc <- c(list_noalloc, n**2)
  }, 
  vector_noalloc_c = for (n in 1:N) {
    vector_noalloc <- c(vector_noalloc, n**2)
  },
  list_prealloc_c = for (n in 1:N) {
    list_prealloc <- c(list_prealloc, n**2)
  },
  vector_prealloc_c = for (n in 1:N) {
    vector_prealloc <- c(vector_prealloc, n**2)
  },
  iterations = 5,
  check = FALSE
)

# A tibble: 8 × 6
  expression                   min   median `itr/sec` mem_alloc `gc/sec`
  <bch:expr>              <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl>
1 list_prealloc_bracket      893µs    926µs   1053.      54.8KB      0  
2 list_noalloc_bracket       898µs    941µs   1025.     830.1KB      0  
3 vector_prealloc_bracket    809µs    895µs    695.      54.8KB    139. 
4 vector_noalloc_bracket     841µs    925µs   1079.     830.1KB      0  
5 list_noalloc_c             413ms    639ms      1.53   286.4MB     31.8
6 vector_noalloc_c           127ms    263ms      4.37   286.4MB     92.7
7 list_prealloc_c            357ms    639ms      1.54   286.4MB     32.6
8 vector_prealloc_c          124ms    220ms      4.35   286.4MB     93.1

next and break

Generally used with if-else condition tests inside loop.

next is used to skip an iteration of loop.

for (i in 1:5) {
  if (i == 3) {
    # skip if i == 3
    next
  }
  print(i)
}

[1] 1
[1] 2
[1] 4
[1] 5

break is used to exit loop immediately.

for (i in 1:5) {
  if (i == 4) {
    break
  }
  print(i)
}

[1] 1
[1] 2
[1] 3

For loop: Compound interest

How to calculate compound interest over multiple years using a for loop?

• Principal: $10,000
• Interest rate: 5%
• Number of years: 10

principal <- 10000
rate <- 0.05
num_periods <- 10
# generate placeholder vector for the cashflow
cashflow <- vector("numeric", length = num_periods)

for (i in 1:num_periods) {
  value <- principal * (1 + rate)^i
  cashflow[[i]] <- value
}
print(cashflow)

 [1] 10500.00 11025.00 11576.25 12155.06 12762.82 13400.96 14071.00 14774.55
 [9] 15513.28 16288.95

Exercise

Based on the previous example, do the following:

• Q1. Skip the first year using if and next

  • Cashflow should have zero (NULL) on the first slot

• Q2. Stop the calculation if value exceeds $14,000

  • Cashflow should have zero (NULL) on slots that exceed value of $14,000

While loops

While loops begin with testing condition, and iterates the code as long as the condition is TRUE.

• If not written properly, it can be infinite loop.

count <- 0
while (count < 3) {
  print(count)
  count <- count + 1 # add 1
}

[1] 0
[1] 1
[1] 2

Exercise 2

Write a function that checks class of an input.

If the input is numeric, print “Numeric input!”, otherwise, print “Not numeric!”

• use inherits(x, "numeric") for logical test.

# example outcome
my_function(c(1, 4, 5))

[1] "Numeric input!"

my_function(c('a', 'b', 'c'))

[1] "Not numeric!"

Function mapping

map function from purrr is an implicit function loop.

• a function f is an input arg for map()
• Succinct and easy to read than for loops
• map() requires tidyverse or purrr package

Example: map()

• Output is always list

plus_one <- function(x) {
  return(x + 1)
}
# need to import tidyverse to use map()
# library(tidyverse)
map(1:3, plus_one) # 1 2 3 is input for plus_one()

[[1]]
[1] 2

[[2]]
[1] 3

[[3]]
[1] 4

With for loop, code tends to be longer and requires preallocation.

# define empty list for output first
temp_list <- vector("list", length = 3)

for (i in 1:3) {
  # assign each to the list
  temp_list[[i]] <- plus_one(i)
}
print(temp_list)

[[1]]
[1] 2

[[2]]
[1] 3

[[3]]
[1] 4

map function 2

If the desired output is not list but atomic vector:

• map_dbl() a numeric (double) vector
• map_chr() a character vector
• map_lgl() a logical vector
• map_int() an integer vector

map(1:3, plus_one) |> class()

[1] "list"

map_dbl(1:3, plus_one) |> class()

[1] "numeric"

Vectorized Operation and Loops

Most function operations in R are vectorized by default.

• Intuitive and faster: easier to read, write
• R is built for those operations in mind
• Avoid using for loops or map if vectorization is possible

Example: portfolio value

stock_prices <- c(150, 250, 100)
shares_held <- c(10, 5, 20)
# multiplication is vectorized
portfolio_value = stock_prices * shares_held
print(portfolio_value) # easy and faster

[1] 1500 1250 2000

A for loop approach:

N <- length(stock_prices) # length 3
portfolio_value <- vector("numeric", N) # container

for (i in 1:N) {
  portfolio_value[[i]] <- stock_prices[[i]] * shares_held[[i]]
}
print(portfolio_value)

[1] 1500 1250 2000

A map approach:

• map * function to two input vectors (price, share)
• map2() for this case, see ?map2 for more info

portfolio_value <- map2(stock_prices, shares_held, `*`)
print(portfolio_value)

[[1]]
[1] 1500

[[2]]
[1] 1250

[[3]]
[1] 2000

Benchmark comparison

bench::mark(
  vectorizing = {portfolio_value <- stock_prices * shares_held},
  map2 = {portfolio_value <- map2(stock_prices, shares_held, `*`)},
  for_loop_prealloc = {
    portfolio_value <- vector("numeric", N) # container
    for (i in 1:N) {
      portfolio_value[[i]] <- stock_prices[[i]] * shares_held[[i]]
    }},
  iterations = 100,
  check = FALSE
)

# A tibble: 3 × 6
  expression             min   median `itr/sec` mem_alloc `gc/sec`
  <bch:expr>        <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl>
1 vectorizing           41ns     82ns  4533503.        0B      0  
2 map2                  46µs  53.51µs    18094.      264B      0  
3 for_loop_prealloc    887µs   1.01ms      983.    20.1KB     30.4

Vectorized if-else

ifelse() function is a vectorized if else statement.

• Useful when you have a vector of TRUE / FASE condition tests
• No need to loop over each element of vector

ifelse(test, yes, no)

Example: Dividend Payments

stock_prices <- c(45, 60, 52, 48, 55, 49)

dividends <- ifelse(
  stock_prices > 50, # test
  stock_prices * 0.02, # yes
  stock_prices * 0.015 # no
)

print(dividends)

[1] 0.675 1.200 1.040 0.720 1.100 0.735

Exercise

stock_prices <- c(45, 60, 52, 48, 55, 49)

Practice ifelse():

• if stock price is greater than 53, assign “Bull”
• otherwise “Bear”
• assign it to sentiment object.

Vectorized if-else 2

case_when() from tidyverse package is a general vectorized if-else.

library(tidyverse)
stock_prices <- c(45, 60, 52, 48, 55, 49)

sentiment2 <- case_when(
  stock_prices > 55 ~ "Bull", # if TRUE
  stock_prices > 53 ~ "Normal", # else if TRUE
  stock_prices > 49 ~ "Weak", # else if TRUE
  .default = "Bear" # else
)
print(sentiment2)

[1] "Bear"   "Bull"   "Weak"   "Bear"   "Normal" "Bear"  

Exercise 2

stock_prices <- c(45, 60, 52, 48, 55, 49)

Practice case_when():

• if stock price is greater than 58, assign “Bull”
• if stock price is greater than 50, assign “Normal”
• otherwise “Bear”
• assign it to sentiment2 object.

Package fs

fs package provides simple and consistent way to:

• Path operations
• File and directory control
• File information
• Cross-platform

# Install package
if (!requireNamespace("fs", quietly = TRUE)) {
  install.packages("fs")
}

What is a Path?

A path is a string of characters used to uniquely identify a file or folder in a file system.

Types of paths:

• Absolute path: exact location of a file or directory from the root.
• Relative path: location relative to the current working directory.

Working Directory

The working directory is the location where the program (R, bash, Python, etc) is running on.

• getwd() shows the current working directory.
• setwd("/path/to/directory") changes working directory to specified path.

Absolute Paths

• Begins from the root directory (/ in Mac/Linux, C:\ in Windows)
• Example (Mac/Linux): /Users/username/Documents/project/data.csv
• Example (Windows): C:\Users\username\Documents\project\data.csv

Absoulte paths are unambiguous.

Relative Paths

• Path that is relative to the current working directory.
• Example: ./data/project/data.csv (The . denotes the current directory)
• Succinct and easier to manage path in projects

Directory references

.: the current directory.

• From /Users/john/projects, ./data refers to /Users/john/projects/data.

..: the parent directory; one level up from the current directory.

• From /Users/john/projects, ../data refers to /Users/john/data.

~: the home directory.

• Default directory for user in OS

Home Directory

The “default” directory for user in operating system

Mac/Linux: /Users/<username>. - Example: If your username is john, your home directory would be /Users/john.

Windows: C:\Users\<username> - Example: If your username is john, your home directory would be C:\Users\john

Tilde ~

Represents the user’s home directory.

Example: ~/cases refers to the cases folder in the user’s home directory:

• C:\Users\<username>\cases for windows
• /Users/john/cases for Mac/Linux

Creating File/Directory

Creatie / delete file and directory are simple:

# Create file and folder in the working directory
library(fs)
file_create("my_Rscript.R")
dir_create("my_folder")

file_delete("my_Rscript.R")
dir_delete("my_folder")

List files and directories

List files and directories:

dir_ls(".") # list files in current directory

It’s especially useful with globbing / regex:

dir_ls(glob = "*.txt") # list txt files

Text Data Files

A plain, human-readable text data file, delimited by a specific character

• Comma-Separated Values (CSV) with ,
• Tab-Separated Values (TSV) with \t
• Since it is text, R tries to “guess” the correct data type of each column when importing

Text Data Example

A text data file typically looks like:

• Usually the first line is a header (column names)
• Data values separated by a delimiter (e.g., , for CSV, \t for TSV)

Sepal.Length,Sepal.Width,Petal.Length,Petal.Width,Species
5.1,3.5,1.4,0.2,setosa
4.9,3,1.4,0.2,setosa
4.7,3.2,1.3,0.2,setosa

# TSV
iris |> head(3) |> format_tsv() |> cat()

Sepal.Length    Sepal.Width Petal.Length    Petal.Width Species
5.1 3.5 1.4 0.2 setosa
4.9 3   1.4 0.2 setosa
4.7 3.2 1.3 0.2 setosa

Text Data files

Many packages support writing/reading csv/tsv files;

• base R (utils package): basic, slow
• readr from tidyverse: extremely fast, functional

Write CSV / TSV

To write a data.frame to a csv file: write_csv()

# Saves csv / tsv file on current working directory
write_csv(iris, "iris_file.csv")
write_tsv(iris, "iris_file.tsv")

To read a .csv / .tsv file to a data.frame: read_csv(), read_tsv()

my_iris <- read_csv('iris_file.csv')
my_iris2 <- read_tsv("iris_file.tsv")

Other data formats

There are other common data formats:

• “.xlsx”: excel spread sheets
• “.json”: javascript object notation (NoSQL)
• “.parquet”: columnar big data storage
• ‘.sas7bdat’, ‘.dta’

Data frames

One of the most important data class in R, built on top of list type.

• Stores data structure in 2D tabular form:

  • with rows (observations, or records)

  • and columns (variables)

• Columns can be different types!

Create data frame

Creating a data.frame is almost identical to list.

# creating data.frame is similar to creating a list
my_dataframe <- data.frame(
  a = c(1, 2, 3),
  b = c('a', 'b', 'c'),
  c = c(TRUE, FALSE, FALSE)
)
print(my_dataframe)

  a b     c
1 1 a  TRUE
2 2 b FALSE
3 3 c FALSE

Exercise

Create a dataframe named as housing:

• 6 columns: Name, Age, Sex, Income, Housing, Zipcode
  • Name: Amy, Bill, Charles, Donna, Eckert
  • Age: 21, 25, 30, 38, 49
  • Sex: Female, Male, Male, Female, Male
  • Income: 36000, 53000, 89000, 82000, 166000
  • Housing: Rent, Rent, Own, Own, Rent
  • Zipcode: 12333, 12543, 11255, 12333, 33533

What are the type (class) of each column automatically recognized by R?

• Check with str(housing).

Q: What should be their type (class) in theory?

Tibble class

Essentially the same as dataframe class, with some fix:

• Fixes old inconsistencies in R data.frame class
• Safer executions
• Better console displays

as_tibble() converts data.frame class to tibble class.

Example

A toy dataset, iris dataframe:

head(iris, 3)

  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa

Class of iris:

class(iris)

[1] "data.frame"

Convert iris to tibble class:

• Prints the dimension
• Prints data class by column

iris_tb <- as_tibble(iris)
head(iris_tb, 3)

# A tibble: 3 × 5
  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
         <dbl>       <dbl>        <dbl>       <dbl> <fct>  
1          5.1         3.5          1.4         0.2 setosa 
2          4.9         3            1.4         0.2 setosa 
3          4.7         3.2          1.3         0.2 setosa 

iris_tb is a multi-class object that is both tibble and dataframe.

class(iris_tb)

[1] "tbl_df"     "tbl"        "data.frame"

Access operations

As it is built on lists, [, [[, $ also works on data.frames.

• bracket operations align more consistently with tibble class

Dataframe can be subsetted with df[i,j]

• i part operates on row (called filtering)
• j part selects columns

Bracket [, [[ subsetting

iris_tb[, 1] # vector? tibble?
iris_tb[1, 1] # vector? tibble?
iris_tb[1,] # vector? tibble?

1st row, 1st column, in element class (numeric vector)

iris_tb[[1, 1]]

[1] 5.1

Other examples:

# Exercise: try!
iris_tb[, c("Sepal.Length", "Petal.Width")]
iris_tb[1:5, 1:2]
iris_tb[iris_tb[["Sepal.Length"]] > 3.1, 1] # filtering

If comma is not provided, it assumes a column index.

# try and see the difference!
iris_tb[1]
iris_tb["Sepal.Length"]
iris_tb[["Sepal.Length"]]

$ subsetting

$ pulls a single column in element’s class from data frame (tibble).

iris_tb$Sepal.Length

Chained subset call

Subsetting can be chained

• Pause and take a look at example. What is happening?

iris_tb[21:100, c('Petal.Length', 'Sepal.Length')][25, ]

• Confirm with iris_tb[45, c("Petal.Length", "Sepal.Length")]

Exercise

On iris_tb,

• Filter with “Petal.Length > 4.5”
• Select columns “Species”, “Petal.Length”
• then slice rows from 1 to 10
• Store this as filtered_iris

Q. Confirm the average of Petal.Length from filtered_iris is 4.74.

• Use mean(dataframe$column).

Assign and remove column

They operate as same as lists. To assign a new variable within the data.frame, use:

data.frame["NEW_COLUMN_NAME"] <- NEW_COLUMN
data.frame[["NEW_COLUMN_NAME"]] <- NEW_COLUMN # same

# EXAMPLE
iris_tb["Petal.Area"] <- iris$Petal.Length * iris$Petal.Width

To remove a variable from the data.frame, use:

data.frame["EXISTING_NAME"] <- NULL
data.frame[["EXISTING_NAME"]] <- NULL

Modern syntax: dplyr package

R package for dataframe manipulation tasks.

• A grammar of data manipulation
• Replaces the use of [, [[, $ in most cases
• Intuitive and easy to understand
• Fast, written in C++

Prep: Company Financials Data

Company_financials.csv data will be available in our GitHub Class repository.

• Option 1: Git pull and copy the data to your class working folder

# install.packages("fs")
# Adjust the address to your setting
fs::file_copy(
  "Class_repo/FIN4770_Spring2025/Data/Company_Financials.csv", # from
  "Company_Financials.csv" # to
  )

• Option 2: Direct address typing as below

library(tidyverse)
url <- "https://raw.githubusercontent.com/matthewgson/FIN4770_Spring2025/refs/heads/main/Data/Company_financials.csv"
fin_data <- read_csv(url)

Data Overview

• Balance Sheet items: Assets, Liabilities, Equity, etc
• Year: reporting year
• Industry: Industry classification for each company
• Company: Ticker symbol

The select() verb

select() lets you choose specific columns.

• by column names
• by index
• by helper functions (starts_with, ends_with, etc)

fin_data |> 
  select(ticker, Industry)  # column names
fin_data |> 
  select(1:5) # index

Suppose you want to select all current items that starts with “current”.

fin_data |> 
  select(ticker, Industry, year, starts_with("current"))

or ends with “libabilities”.

fin_data |> 
  select(ticker, Industry, year, ends_with("liabilities"))

or contains “asset”

fin_data |> 
  select(ticker, Industry, year, contains("asset"))

The relocate() verb

relocate() is used to change the order of columns.

fin_data |> 
  relocate(market_cap) # move to left-most

fin_data |> 
  relocate(market_cap, .before = market_cap) # move before market_cap

fin_data |> 
  relocate(market_cap, .after = last_col()) # move to far-right

The rename() verb

rename() changes the column names.

fin_data |> 
  rename(
    Ticker = ticker, # left is new name
    Year = year
  )

The pull() verb

pull() extracts a single column as a vector.

fin_data |> 
  pull(ticker) # vector

fin_data |> 
  select(ticker) # tibble

The filter() verb

filter() lets you choose rows based on conditions.

# Single filter
fin_data |> 
  filter(year >= 2022)

# Multiple filter
fin_data |> 
  filter(
    year >= 2022,
    Industry == "Financials"
  )

fin_data |> 
  filter(
    between(market_cap, 1e11, 1e12), # between 100B to 1T
    Industry %in% c("Financials", "Energy")
  )

Apply filters across columns: if_any() and if_all()

Imagine your dataset includes multiple asset columns (e.g., current assets and current liabilities). You want to filter rows where any asset value exceeds $100B (1e11).

fin_data |> \
  filter(
    if_any(
      c(current_assets, current_liabilities), \(x) x > 1e11))

if_all() for strict filtering:

fin_data |> 
  filter(
    if_all(
      c(current_assets, current_liabilities), \(x) x > 1e11))

The slice() verb

slice() extrats rows based on simple positions.

fin_data |> 
  slice(1:5) 

fin_data |> 
  slice(-(1:10)) # drop

fin_data |> 
  slice_sample(n = 10) # random

fin_data |> 
  slice_max(current_assets, n = 3) # top 3 values

The disctinct() verb

distinct() removes duplicate rows based on referred columns.

fin_data |> 
  distinct(Industry) # distinct values of Industry

fin_data |> 
  distinct(Industry, .keep_all = TRUE) # keeps other columns

The arrange() verb

arrange() reorders the rows by one or more columns.

fin_data |> 
  arrange(current_assets) # ascending by default

fin_data |> 
  arrange(desc(current_assets)) # descending

fin_data |> 
  arrange(ticker, year, current_assets) # hierachical ordering

The mutate() verb

mutate() lets you create or modify columns.

fin_data |> 
  mutate(
    debt_asset_ratio = current_debt / current_assets,
    equity = total_assets - total_debt
  )

Using general if-else with case_when() to classify:

fin_data |> 
  mutate(
    debt_asset_ratio = current_debt / current_assets,
    Leverage_category = case_when(
      debt_asset_ratio >= 0.8 ~ "High Leverage",
      debt_asset_ratio >= 0.5 ~ "Moderate Leverage",
      TRUE ~ "Low Leverage")
      )

The summarize() verb

summarize() computes statistics for the entire dataset.

fin_data |> 
  summarize(
    avg_current_assets = mean(current_assets, na.rm = TRUE),
    max_assets = max(current_assets, na.rm = TRUE)
  )

You can summarize by groups:

fin_data |> 
  group_by(ticker) |> 
  summarize(
    avg_current_assets = mean(current_assets, na.rm = TRUE)
  ) |> 
  ungroup() # manual ungroup needed

Or simply use .by in the summarize()

fin_data |> 
  summarize(
    avg_current_assets = mean(current_assets, na.rm = TRUE),
    .by = ticker
  ) # ungroupped after summary

Incorporating AI for Coding

From now on, I’ll introduce how to leverage AI for coding.

• Generating code snippets

• Troubleshoot and debug

• Best Practices

Crypto Analysis with dplyr and tidyverse

Learn to:

• Financial data manipulation
• Calculate average returns and volatility
• Sort cryptocurrencies into portfolios
• Compare performance of different portfolios
• Visualize performance

Let’s optimize our crypto investments!

Prep Required Libraries

# Install yourself before loading
library(tidyquant) 
library(tidyverse)

Our list of cryptos: 9 sample

crypto_coins <- c("BTC-USD", "ETH-USD", "BNB-USD", 
                  "SOL-USD", "XRP-USD", "DOT-USD", 
                  "DOGE-USD", "MATIC-USD", "ADA-USD")

Get data

# Get historical prices for the selected coins
crypto_data <- tq_get(crypto_coins,
                      from = "2020-01-01",
                      to = "2023-01-01") # 3 years

How many observations are found for each crpto?

# Not all of coins have same number of observations
crypto_data |> 
  summarize(n(), .by = symbol) 

# A tibble: 9 × 2
  symbol    `n()`
  <chr>     <int>
1 BTC-USD    1097
2 ETH-USD    1097
3 BNB-USD    1097
4 SOL-USD     997
5 XRP-USD    1097
6 DOT-USD     865
7 DOGE-USD   1097
8 MATIC-USD  1097
9 ADA-USD    1097

Calculate Returns

Calculate daily returns with arrange(), group_by() and mutate()

crypto_data <- crypto_data |> 
  arrange(symbol, date) |> 
  group_by(symbol) |> 
  mutate(daily_ret = adjusted / lag(adjusted) - 1) |> # arithmetic return
  ungroup()

crypto_data |> head()

# A tibble: 6 × 9
  symbol  date         open   high    low  close   volume adjusted daily_ret
  <chr>   <date>      <dbl>  <dbl>  <dbl>  <dbl>    <dbl>    <dbl>     <dbl>
1 ADA-USD 2020-01-01 0.0328 0.0338 0.0327 0.0335 22948374   0.0335  NA      
2 ADA-USD 2020-01-02 0.0335 0.0335 0.0324 0.0328 20843934   0.0328  -0.0211 
3 ADA-USD 2020-01-03 0.0327 0.0344 0.0325 0.0342 30162644   0.0342   0.0436 
4 ADA-USD 2020-01-04 0.0342 0.0347 0.0339 0.0346 29535781   0.0346   0.0121 
5 ADA-USD 2020-01-05 0.0346 0.0354 0.0345 0.0347 21479178   0.0347   0.00364
6 ADA-USD 2020-01-06 0.0348 0.0373 0.0347 0.0373 37988444   0.0373   0.0735 

Performance metrics

Calculate performance metrics with group_by() and summarize()

performance_metrics <- crypto_data |> 
  group_by(symbol) |> 
  summarize(
    avg_daily_ret = mean(daily_ret, na.rm = TRUE), 
    vol_daily = sd(daily_ret, na.rm = TRUE)
  )
performance_metrics